"""
转置数字-处理溢出的技巧
反转一个整数的各位数字。
示例 1：x = 123，返回 321
示例 2：x = -123，返回 -321

思路
这题完全没丝毫的难度，任何人几分钟都可以写出来，但是，这题修改后，加入了一个新的测试，瞬间大家讨论的就多了，就是——溢出测试

因为整数只有32位，可能原数不会溢出，但是转置后就不一定了，所以必须要考虑溢出的情况。

思路1 --用 long 直接用long不会溢出再和INT_MAX比较就好

根据所选代码上下文，您正在处理一个**反转整数各位数字**的问题，并且需要考虑**溢出**情况（即超出 32 位有符号整数范围 `[-2^31, 2^31 - 1]`）。

---

### ✅ 问题描述

给定一个整数 `x`，将其各位数字**反转**，并返回结果。
如果反转后的数值**超过 32 位有符号整数的范围**，则返回 `0`。

#### 示例：
- 输入：`123` → 输出：`321`
- 输入：`-123` → 输出：`-321`
- 输入：`120` → 输出：`21`

---

### 🔍 解题思路

1. **处理符号**：先记录整数的符号，将负数转为正数处理。
2. **逐位取余反转**：通过循环不断取出最后一位数字 (`x % 10`)，然后构建新的反转数。
3. **溢出判断**：每一步反转后都检查是否超出 `[-2^31, 2^31 - 1]` 范围，若超出直接返回 `0`。
4. **返回结果**：带上原始符号返回反转后的整数。

---

### 🧩 Python 实现代码如下：

```python
def reverse_integer(x: int) -> int:

    反转整数 x 的各位数字，并在结果超出 32 位有符号整数范围时返回 0。

    参数:
    x: int - 待反转的整数。

    返回:
    int - 反转后的整数，或 0（如果溢出）。

    INT_MIN, INT_MAX = -2**31, 2**31 - 1

    sign = -1 if x < 0 else 1
    x_abs = abs(x)
    reversed_num = 0

    while x_abs != 0:
        digit = x_abs % 10
        x_abs //= 10

        # 溢出检查：反转过程中提前判断是否会超出范围
        if reversed_num > (INT_MAX - digit) // 10:
            return 0

        reversed_num = reversed_num * 10 + digit

    return sign * reversed_num
```


---

### 📌 示例运行

```python
print(reverse_integer(123))     # 输出: 321
print(reverse_integer(-123))    # 输出: -321
print(reverse_integer(120))     # 输出: 21
print(reverse_integer(1534236469))  # 输出: 0（溢出）
```


---

### ⚠️ 关键点说明

- **溢出检测技巧**：
  在每次拼接新数字前，使用以下条件判断是否会溢出：
  ```python
  if reversed_num > (INT_MAX - digit) // 10:
      return 0
  ```

  这样可以避免实际溢出后再判断，提升性能和安全性。

- **时间复杂度**：`O(log(x))`，因为每次除以 10，所以循环次数与输入整数的位数成对数关系。
- **空间复杂度**：`O(1)`，只使用了常数级额外空间。

---

### ✅ 总结

本题的关键在于**反转整数的同时防止溢出**，可以通过控制反转过程中的边界条件来实现。该方法适用于所有有符号 32 位整数的场景。

以下是对 [reverse_integer](file://E:\code1\leetcode100\demo_100_23.py#L109-L126) 函数的**中文逐行解释**，帮助理解该算法是如何实现整数反转并处理溢出问题的。

---

### 🧩 函数定义

```python
def reverse_integer(self, x: int) -> int:
```


- 定义一个函数 [reverse_integer](file://E:\code1\leetcode100\demo_100_23.py#L109-L126)，接收一个整数 `x`，返回一个整数。
- 该函数的目标是：**将输入整数的各位数字反转**，并在反转结果**超出 32 位有符号整数范围**时返回 `0`。

---

### 🔢 定义 32 位整数范围

```python
INT_MAX, INT_MIN = 2**31 - 1, -2**31
```


- 设置最大值和最小值限制：
  - 最大值：`2^31 - 1 = 2147483647`
  - 最小值：`-2^31 = -2147483648`
- 如果反转后的数字超过这个范围，就返回 `0`。

---

### 🎯 判断正负号

```python
sign = -1 if x < 0 else 1
```


- 如果 `x` 是负数，则 `sign = -1`；否则 `sign = 1`。
- 这个变量用来记录原始整数的符号，在最后加上符号返回。

---

### 🔁 取绝对值处理反转更简单

```python
x_abs = abs(x)
```


- 把 `x` 转成正数处理，方便后面统一操作。

---

### 🔄 初始化反转后的数字

```python
reversed_num = 0
```


- `reversed_num` 用于保存反转后的数字，初始为 `0`。

---

### 🔁 循环处理每一位数字（核心逻辑）

```python
while x_abs != 0:
```


- 当 `x_abs` 不为 `0` 时循环，即还有数字未处理完。

---

#### 📌 拿到当前最后一位数字：

```python
digit = x_abs % 10
```


- 用 `% 10` 拿到最后一位数字。例如：`123 % 10 = 3`。

---

#### 📌 去掉最后一位：

```python
x_abs //= 10
```


- 用整除 `// 10` 去掉最后一位。例如：`123 // 10 = 12`。

---

#### ⚠️ 溢出检查（关键步骤）

```python
if reversed_num > (INT_MAX - digit) // 10:
    return 0
```


- 在把新的 `digit` 添加到 `reversed_num` 之前，先判断是否会**导致溢出**。
- 这个公式是为了防止在拼接新数字后直接溢出而无法判断。
- 举个例子：如果 `reversed_num = 214748364`，此时再乘以 10 并加上 `8`，就会变成 `2147483648`，超过 `INT_MAX(2147483647)`，所以提前返回 `0`。

---

#### ✅ 构建反转后的数字

```python
reversed_num = reversed_num * 10 + digit
```


- 将当前数字拼接到 `reversed_num` 的末尾。
- 例如：`reversed_num = 3` → `3 * 10 + 2 = 32`。

---

### 📤 返回最终结果（带上符号）

```python
return sign * reversed_num
```


- 把反转后的数字乘以原来的符号（正或负）后返回。

---

### 🧪 示例执行流程说明（以 `x = 123` 为例）

1. `x = 123`, `sign = 1`, `x_abs = 123`, `reversed_num = 0`
2. 第一次循环：
   - `digit = 3`, `x_abs = 12`
   - `reversed_num = 0 * 10 + 3 = 3`
3. 第二次循环：
   - `digit = 2`, `x_abs = 1`
   - `reversed_num = 3 * 10 + 2 = 32`
4. 第三次循环：
   - `digit = 1`, `x_abs = 0`
   - `reversed_num = 32 * 10 + 1 = 321`
5. 结束循环，返回 `1 * 321 = 321`

---

### ❗ 特殊情况处理（如溢出）

例如输入 `x = 1534236469`，反转后应为 `9646324351`，远大于 `INT_MAX = 2147483647`，所以在循环中会提前检测到溢出，返回 `0`。

---

### ✅ 总结

这段代码通过**逐位取余、构建反转数**的方式实现了整数反转，并通过**提前判断溢出条件**保证了程序的安全性和健壮性。整体逻辑清晰，时间复杂度为 `O(log(x))`，空间复杂度为 `O(1)`，非常高效。


"""


class Solution:
    def reverse_integer(self, x: int) -> int:

        INT_MAX, INT_MIN = 2**31 - 1, -2**31
        sign = -1 if x < 0 else 1
        x_abs = abs(x)
        reversed_num = 0

        while x_abs !=0:
            digit = x_abs % 10
            x_abs //= 10

            # 溢出检查：反转过程中提前判断是否会超出范围
            if reversed_num > (INT_MAX - digit) // 10:
                return 0

            reversed_num = reversed_num * 10 + digit

        return sign * reversed_num

